home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / Other Langs / Tickle-4.0 (tcl) / tcl / extend / src.unused / tcl++.h < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-26  |  14.9 KB  |  608 lines  |  [TEXT/MPS ]
  1. /*
  2.  * tcl++.h --
  3.  *
  4.  * This file defines a C++ classes that can be used to access a Tcl
  5.  * interpreter. If tcl.h is not already included, it includes it. Tcl.h has
  6.  * macros that allow it to work with K&R C, ANSI C and C++.
  7.  *-----------------------------------------------------------------------------
  8.  * Copyright 1991-1993 Karl Lehenbauer and Mark Diekhans.
  9.  *
  10.  * Permission to use, copy, modify, and distribute this software and its
  11.  * documentation for any purpose and without fee is hereby granted, provided
  12.  * that the above copyright notice appear in all copies.  Karl Lehenbauer and
  13.  * Mark Diekhans make no representations about the suitability of this
  14.  * software for any purpose.  It is provided "as is" without express or
  15.  * implied warranty.
  16.  *-----------------------------------------------------------------------------
  17.  * Based on Tcl C++ classes developed by Parag Patel.
  18.  *-----------------------------------------------------------------------------
  19.  * $Id: tcl++.h,v 2.11 1993/08/31 23:03:20 markd Exp $
  20.  *-----------------------------------------------------------------------------
  21.  */
  22.  
  23. #ifndef _TCL_PLUS_PLUS_H
  24. #define _TCL_PLUS_PLUS_H
  25.  
  26. #include <stddef.h>
  27. #include <stdlib.h>
  28. #include <string.h>
  29. #include <stdarg.h>
  30. #ifndef TCLEXTEND_H
  31. #    include "tclExtend.h"
  32. #endif
  33.  
  34. class TclInterp_cl
  35. {
  36.     Tcl_Interp *interp;
  37.  
  38.     friend class TclTrace_cl;
  39.  
  40. private:
  41.     char *
  42.     CatVarArgs (va_list  argPtr);
  43.  
  44. public:
  45.     inline 
  46.     TclInterp_cl () 
  47.     {
  48.         interp = Tcl_CreateExtendedInterp ();
  49.     }
  50.  
  51.     inline 
  52.     ~TclInterp_cl () 
  53.     { 
  54.         Tcl_DeleteInterp (interp);
  55.     }
  56.  
  57.     inline char *
  58.     Result () 
  59.     { 
  60.         return interp->result; 
  61.     }
  62.  
  63.     inline int 
  64.     ErrorLine () 
  65.     { 
  66.         return interp->errorLine;
  67.     }
  68.  
  69.     inline Tcl_Interp *
  70.     GetInterp () 
  71.     {
  72.         return interp;
  73.     }
  74.  
  75.    /*
  76.     * Exported Tcl procedures (from standard baseline):
  77.     */
  78.  
  79.     inline void
  80.     AppendElement (const char *string)
  81.     { 
  82.         Tcl_AppendElement (interp, (char *) string);
  83.     }
  84.  
  85.     void
  86.     AppendResult (const char *p,
  87.                   ...);
  88.  
  89.     inline void
  90.     AddErrorInfo (const char *message)
  91.     {
  92.         Tcl_AddErrorInfo (interp, (char *)message);
  93.     }
  94.  
  95.     inline void
  96.     CallWhenDeleted (Tcl_InterpDeleteProc *proc,
  97.                      ClientData            clientData)
  98.     {
  99.         Tcl_CallWhenDeleted (interp, proc, clientData);
  100.     }
  101.  
  102.     inline void 
  103.     CreateCommand (const char        *cmdName,
  104.                    Tcl_CmdProc       *proc, 
  105.                    ClientData         data, 
  106.                    Tcl_CmdDeleteProc *deleteProc)
  107.     { 
  108.         Tcl_CreateCommand (interp, (char*) cmdName, proc, data, deleteProc);
  109.     }
  110.  
  111.     inline void
  112.     CreateMathFunc (const char    *name,
  113.                     int            numArgs,
  114.                     Tcl_ValueType *argTypes,
  115.                     Tcl_MathProc  *proc,
  116.                     ClientData     clientData)
  117.     {
  118.         Tcl_CreateMathFunc (interp, (char *) name, numArgs, argTypes,
  119.                 proc,  clientData);
  120.     }
  121.  
  122.     inline int
  123.     CreatePipeline (int    argc, 
  124.                     char **argv, 
  125.                     int  **pidArrayPtr,
  126.                     int   *inPipePtr, 
  127.                     int   *outPipePtr,
  128.                     int   *errFilePtr)
  129.     {
  130.         return Tcl_CreatePipeline (interp, argc, argv, pidArrayPtr, inPipePtr, 
  131.                                    outPipePtr, errFilePtr);
  132.     }
  133.  
  134.     inline Tcl_Trace 
  135.     CreateTrace (int               level, 
  136.                  Tcl_CmdTraceProc *proc, 
  137.                  ClientData        data)
  138.     {
  139.         return Tcl_CreateTrace (interp, level, proc, data);
  140.     }
  141.  
  142.     inline void 
  143.     DeleteCommand (const char *cmdName)
  144.     { 
  145.         Tcl_DeleteCommand (interp, (char *)cmdName);
  146.     }
  147.  
  148.     inline void 
  149.     DeleteTrace (Tcl_Trace trace)
  150.     { 
  151.         Tcl_DeleteTrace(interp, trace);
  152.     }
  153.  
  154.     inline void
  155.     DetachPids (int  numPids, 
  156.                 int *pidPtr)
  157.     {
  158.         Tcl_DetachPids (numPids, pidPtr);
  159.     }
  160.  
  161.     inline void
  162.     EnterFile (FILE  *file,
  163.                int    permissions)
  164.     {
  165.         Tcl_EnterFile (interp, file, permissions);
  166.     }
  167.  
  168.     inline void
  169.     ErrorAbort (int  noStackDump,
  170.                 int  exitCode)
  171.     {
  172.         Tcl_ErrorAbort (interp, noStackDump, exitCode);
  173.     }
  174.  
  175.     inline int 
  176.     Eval (char  *cmd)
  177.     {
  178.         return Tcl_Eval (interp, cmd);
  179.     }
  180.  
  181.     inline int
  182.     EvalFile (const char *fileName)
  183.     { 
  184.         return Tcl_EvalFile (interp, (char *) fileName);
  185.     }
  186.  
  187.     inline int
  188.     ExprBoolean (const char *string,
  189.                  int        *ptr)
  190.     {
  191.         return Tcl_ExprBoolean (interp, (char *) string, ptr);
  192.     }
  193.  
  194.     inline int
  195.     ExprDouble (const char *string,
  196.                 double     *ptr)
  197.     { 
  198.         return Tcl_ExprDouble (interp, (char *) string, ptr);
  199.     }
  200.  
  201.     inline int
  202.     ExprLong (const char *string,
  203.               long       *ptr)
  204.     {
  205.         return Tcl_ExprLong (interp, (char *) string, ptr);
  206.     }
  207.  
  208.     inline int
  209.     ExprString (const char *string)
  210.     {
  211.         return Tcl_ExprString (interp, (char *) string);
  212.     }
  213.  
  214.     inline int
  215.     GetBoolean (const char *string,
  216.                 int        *boolPtr)
  217.     { 
  218.         return Tcl_GetBoolean (interp, (char *) string, boolPtr);
  219.     }
  220.  
  221.     inline int
  222.     GetCommandInfo (const char  *cmdName,
  223.                     Tcl_CmdInfo *infoPtr)
  224.     {
  225.         return Tcl_GetCommandInfo (interp, (char *) cmdName, infoPtr);
  226.     }
  227.  
  228.     inline int
  229.     GetDouble (const char *string,
  230.                double     *doublePtr)
  231.     { 
  232.         return Tcl_GetDouble (interp, (char *) string, doublePtr);
  233.     }
  234.  
  235.     inline int
  236.     GetInt (const char *string,
  237.             int        *intPtr)
  238.     { 
  239.         return Tcl_GetInt (interp, (char *) string, intPtr);
  240.     }
  241.  
  242.     inline int
  243.     GetOpenFile (const char *string,
  244.                  int         write,
  245.                  int         checkUsage,
  246.                  FILE      **filePtr)
  247.     {
  248.         return Tcl_GetOpenFile (interp, (char *) string, write, checkUsage,
  249.                                 filePtr);
  250.     }
  251.  
  252.     inline const char *
  253.     GetVar (const char *varName, 
  254.             int         flags = 0)
  255.     { 
  256.         return Tcl_GetVar (interp, (char *) varName, flags);
  257.     }
  258.  
  259.     inline const char *
  260.     GetVar2 (const char *part1, 
  261.              const char *part2,
  262.              int         flags = 0)
  263.     { 
  264.         return Tcl_GetVar2 (interp, (char *) part1, (char *) part2, flags); 
  265.     }
  266.  
  267.     inline int
  268.     LinkVar (const char *varName,
  269.              char       *addr,
  270.              int         type)
  271.     {
  272.         return Tcl_LinkVar (interp, (char *) varName, addr, type);
  273.     }
  274.  
  275.     inline char *
  276.     ParseVar (const char  *string, 
  277.               char       **termPtr)
  278.        { return Tcl_ParseVar (interp, (char *) string, termPtr); }
  279.  
  280.     inline const char *
  281.     PosixError ()
  282.     {
  283.         return Tcl_PosixError (interp);
  284.     }
  285.  
  286.     inline int 
  287.     RecordAndEval (const char *cmd, 
  288.                    char        flags)
  289.         { return Tcl_RecordAndEval (interp, (char *) cmd, flags); }
  290.  
  291.     inline void
  292.     ResetResult ()
  293.     {
  294.         Tcl_ResetResult (interp);
  295.     }
  296.  
  297.     inline int
  298.     SetCommandInfo (const char  *cmdName,
  299.                     Tcl_CmdInfo *infoPtr)
  300.     {
  301.         return Tcl_SetCommandInfo (interp, (char *) cmdName, infoPtr);
  302.     }
  303.  
  304.     void
  305.     SetErrorCode (char *p, 
  306.                   ...);
  307.  
  308.     inline int
  309.     SetRecursionLimit (int depth)
  310.     {
  311.         return Tcl_SetRecursionLimit (interp, depth);
  312.     }
  313.  
  314.     inline void 
  315.     SetResult (const char *string)
  316.     {
  317.         Tcl_SetResult (interp, (char *) string, TCL_VOLATILE);
  318.     }
  319.  
  320.     inline void 
  321.     SetResult (const char   *string, 
  322.                Tcl_FreeProc *freeProc)
  323.     { 
  324.         Tcl_SetResult (interp, (char *) string, freeProc);
  325.     }
  326.  
  327.     inline const char *
  328.     SetVar (const char  *varName, 
  329.             const char  *newValue, 
  330.             int          global = 0)
  331.     { 
  332.         return Tcl_SetVar (interp, (char *) varName, (char *) newValue, 
  333.                            global);
  334.     }
  335.  
  336.     inline const char *
  337.     SetVar2 (const char *part1, 
  338.              const char *part2, 
  339.              const char *newValue, 
  340.              int         global)
  341.     {
  342.          return Tcl_SetVar2 (interp, (char *) part1, (char *) part2, 
  343.                              (char *) newValue, global);
  344.     }
  345.  
  346.     inline int 
  347.     SplitList (const char   *list,
  348.                int          &argcPtr,
  349.                char       **&argvPtr)
  350.     {
  351.         return Tcl_SplitList (interp, (char *) list, &argcPtr, &argvPtr);
  352.     }
  353.  
  354.     inline char *
  355.     TildeSubst (const char  *name,
  356.                 Tcl_DString *bufferPtr)
  357.     {
  358.         return Tcl_TildeSubst (interp, (char *) name, bufferPtr);
  359.     }
  360.  
  361.     int
  362.     TraceVar (const char       *varName,
  363.               int               flags,
  364.               Tcl_VarTraceProc *proc,
  365.               ClientData        clientData)
  366.     {
  367.          return Tcl_TraceVar (interp, (char *) varName, flags, proc,
  368.                               clientData);
  369.     }
  370.  
  371.     inline int
  372.     TraceVar2 (const char       *part1, 
  373.                const char       *part2,
  374.                int               flags, 
  375.                Tcl_VarTraceProc *proc, 
  376.                ClientData        clientData)
  377.     {
  378.          return Tcl_TraceVar2 (interp, (char *) part1, (char *) part2, flags,
  379.                                proc, clientData); 
  380.     }
  381.  
  382.     inline void
  383.     UnlinkVar (const char *varName)
  384.     {
  385.         Tcl_UnlinkVar (interp, (char *) varName);
  386.     }
  387.  
  388.     inline void
  389.     UnsetVar (const char *varName,
  390.               int         global)
  391.     {
  392.         Tcl_UnsetVar (interp, (char *) varName, global);
  393.     }
  394.  
  395.     inline void
  396.     UnsetVar2 (const char *part1, 
  397.                const char *part2, 
  398.                int         global)
  399.     {
  400.         Tcl_UnsetVar2 (interp, (char *) part1, (char *) part2, global);
  401.     }
  402.  
  403.     inline void
  404.     UntraceVar (const char       *varName, 
  405.                 int               flags,
  406.                 Tcl_VarTraceProc *proc, 
  407.                 ClientData        clientData)
  408.     {
  409.         Tcl_UntraceVar (interp, (char *) varName, flags, proc, clientData);
  410.     }
  411.  
  412.  
  413.     inline void
  414.     UntraceVar2 (const char       *part1,
  415.                  const char       *part2,
  416.                  int               flags, 
  417.                  Tcl_VarTraceProc *proc, 
  418.                  ClientData        clientData)
  419.     { 
  420.         Tcl_UntraceVar2 (interp, (char *) part1, (char *) part2, flags, proc,
  421.                          clientData);
  422.     }
  423.  
  424.     int
  425.     VarEval (const char *p,
  426.               ...);
  427.  
  428.     inline ClientData
  429.     VarTraceInfo (const char       *varName,
  430.                   int               flags,
  431.                   Tcl_VarTraceProc *procPtr,
  432.                   ClientData        prevClientData)
  433.     { 
  434.         return Tcl_VarTraceInfo (interp, (char *) varName, flags, procPtr,
  435.                                  prevClientData);
  436.     }
  437.  
  438.     inline ClientData
  439.     VarTraceInfo2 (const char       *part1, 
  440.                    const char       *part2, 
  441.                    int               flags,
  442.                    Tcl_VarTraceProc *procPtr,
  443.                    ClientData        prevClientData)
  444.     { 
  445.         return Tcl_VarTraceInfo2 (interp, (char *) part1, (char *) part2, 
  446.                                   flags, procPtr, prevClientData);
  447.     }
  448.  
  449.     /*
  450.      * Exported Tcl functions added to baseline Tcl by the Extended Tcl 
  451.      * implementation.
  452.      */
  453.  
  454.     inline char *
  455.     DeleteKeyedListField (const char  *fieldName,
  456.                           const char  *keyedList)
  457.     {
  458.         return Tcl_DeleteKeyedListField (interp, fieldName, keyedList);
  459.     }
  460.  
  461.     inline int
  462.     GetKeyedListField (const char  *fieldName,
  463.                        const char  *keyedList,
  464.                        char       **fieldValuePtr)
  465.     {
  466.         return Tcl_GetKeyedListField (interp, fieldName, keyedList,
  467.                                       fieldValuePtr);
  468.     }
  469.  
  470.     inline int
  471.     GetKeyedListKeys (const char  *subFieldName,
  472.                       const char  *keyedList,
  473.                       int         *keyesArgcPtr,
  474.                       char      ***keyesArgvPtr)
  475.     {
  476.  
  477.         return Tcl_GetKeyedListKeys (interp, subFieldName, keyedList,
  478.                                      keyesArgcPtr, keyesArgvPtr);
  479.     }
  480.  
  481.     inline int
  482.     GetLong (const char *string,
  483.              long       *longPtr)
  484.     {
  485.         return Tcl_GetLong (interp, string, longPtr);
  486.     }
  487.  
  488.     inline int
  489.     GetUnsigned (const char *string,
  490.                  unsigned   *unsignedPtr)
  491.     {
  492.          return Tcl_GetUnsigned (interp, string, unsignedPtr);
  493.     }
  494.  
  495.     inline int
  496.     ProcessInitFile (const char  *dirEnvVar,
  497.                      const char  *dir1,
  498.                      const char  *dir2,
  499.                      const char  *dir3,
  500.                      const char  *initFile)
  501.     {
  502.         return Tcl_ProcessInitFile (interp,
  503.                                     (char *) dirEnvVar,
  504.                                     (char *) dir1,
  505.                                     (char *) dir2,
  506.                                     (char *) dir3,
  507.                                     (char *) initFile);
  508.     }
  509.  
  510.     inline char *
  511.     SetKeyedListField (const char  *fieldName,
  512.                        const char  *fieldvalue,
  513.                        const char  *keyedList)
  514.     {
  515.         return Tcl_SetKeyedListField (interp, fieldName, fieldvalue,
  516.                                       keyedList);
  517.     }
  518.  
  519.     inline int
  520.     ShellEnvInit (unsigned  options)
  521.     {
  522.          return Tcl_ShellEnvInit (interp, options);
  523.     }
  524.  
  525.     inline void 
  526.     Startup (unsigned        options,
  527.              int             argc,
  528.              const char    **argv)
  529.     {
  530.         Tcl_Startup (interp, options, argc, argv);
  531.     }
  532. };
  533.  
  534. class TclTrace_cl
  535. {
  536.     Tcl_Trace   trace;
  537.     Tcl_Interp *interp;
  538.  
  539. public:
  540.     inline 
  541.     TclTrace_cl (TclInterp_cl     &interpCl, 
  542.                  int               level, 
  543.                  Tcl_CmdTraceProc *proc, 
  544.                  ClientData        data)
  545.     { 
  546.         trace = Tcl_CreateTrace (interp = interpCl.interp, level, proc, data);
  547.     }
  548.  
  549.     inline ~TclTrace_cl () 
  550.         { Tcl_DeleteTrace (interp, trace); }
  551. };
  552.  
  553. class TclHandleTbl_cl
  554. {
  555.     void_pt headerPtr;
  556.  
  557. public:
  558.     inline
  559.     TclHandleTbl_cl (const char *handleBase,
  560.                      int         entrySize,
  561.                      int         initEntries)
  562.  
  563.     {
  564.         headerPtr = Tcl_HandleTblInit (handleBase, entrySize, initEntries);
  565.     }
  566.  
  567.     inline
  568.     ~TclHandleTbl_cl ()
  569.     {
  570.         Tcl_HandleTblRelease (headerPtr);
  571.     }
  572.  
  573.     inline void_pt  
  574.     HandleAlloc (char *handlePtr)
  575.     {
  576.         return Tcl_HandleAlloc (headerPtr, handlePtr);
  577.     }
  578.  
  579.     inline void 
  580.     HandleFree (void_pt  entryPtr)
  581.     {
  582.         Tcl_HandleFree (headerPtr, entryPtr);
  583.     }
  584.  
  585.     inline int
  586.     HandleTblUseCount (int amount)
  587.     {
  588.         return Tcl_HandleTblUseCount (headerPtr, amount);
  589.     }
  590.  
  591.     inline void_pt
  592.     HandleWalk (int *walkKeyPtr)
  593.     {
  594.         return Tcl_HandleWalk (headerPtr, walkKeyPtr);
  595.     }
  596.  
  597.     inline void_pt
  598.     HandleXlate (Tcl_Interp  *interp,
  599.                  const  char *handle)
  600.     {
  601.         return Tcl_HandleXlate (interp, headerPtr, handle);
  602.     }
  603. };
  604.  
  605. #endif /* _TCL_PLUS_PLUS_H */
  606.  
  607.  
  608.